﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class YoozooGameplayLibertyBlueprintUtilsWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(Yoozoo.Gameplay.Liberty.BlueprintUtils);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 147, 8, 8);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPlayerCamera", _m_GetPlayerCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCamera", _m_GetCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsPlayerTriggerCollider", _m_IsPlayerTriggerCollider_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasBeenRecorded", _m_HasBeenRecorded_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearAllRecord", _m_ClearAllRecord_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetBlueprintPoint", _m_GetBlueprintPoint_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRandomBlueprintPoint", _m_GetRandomBlueprintPoint_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeCameraBlend", _m_ChangeCameraBlend_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchMovementInput", _m_SwitchMovementInput_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchRootMotion", _m_SwitchRootMotion_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCameraInput", _m_SwitchCameraInput_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnlySwitchCameraInput", _m_OnlySwitchCameraInput_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchPlayerInputController", _m_SwitchPlayerInputController_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TryGetBlueprintCounter", _m_TryGetBlueprintCounter_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPlayerFreeAimOpen", _m_SetPlayerFreeAimOpen_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPlayerKeepBattleDuration", _m_SetPlayerKeepBattleDuration_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayerTransmission", _m_PlayerTransmission_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPlayerDestination", _m_SetPlayerDestination_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsMainPlayer", _m_IsMainPlayer_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayTimeline", _m_PlayTimeline_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "StopTimeline", _m_StopTimeline_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Pause", _m_Pause_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Resume", _m_Resume_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayEffect", _m_PlayEffect_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "DestroyEffect", _m_DestroyEffect_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddNpc", _m_AddNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveNpc", _m_RemoveNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetNpc", _m_GetNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPlayerNpcRigidBody", _m_GetPlayerNpcRigidBody_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OperateLookAtCamera", _m_OperateLookAtCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OperatePlayerInputCamera", _m_OperatePlayerInputCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2LookAtCamera", _m_Switch2LookAtCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ResetInputCamera", _m_ResetInputCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2InputCamera", _m_Switch2InputCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2HangingCamera", _m_Switch2HangingCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2BehaviorCamera", _m_Switch2BehaviorCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLightController", _m_GetLightController_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetIsInGuide", _m_SetIsInGuide_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsInMainUI", _m_IsInMainUI_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasRadarItem", _m_HasRadarItem_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AutoReqClaimBuildingReward", _m_AutoReqClaimBuildingReward_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CallLuaFuncSwitch", _m_CallLuaFuncSwitch_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTroopHeroCount", _m_GetTroopHeroCount_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsUiShowing", _m_IsUiShowing_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsGuideConditionMatch", _m_IsGuideConditionMatch_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsInScene", _m_IsInScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SendRecordRequest", _m_SendRecordRequest_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SendGuideRequest", _m_SendGuideRequest_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenCloseUI", _m_OpenCloseUI_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UIIsShowing", _m_UIIsShowing_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowDialoguePanel", _m_ShowDialoguePanel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowMovieBlackEffect", _m_ShowMovieBlackEffect_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UnlockAirWall", _m_UnlockAirWall_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LockAirWall", _m_LockAirWall_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddFeatureAirWall", _m_AddFeatureAirWall_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityScene", _m_SwitchCityScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2HangingScene", _m_Switch2HangingScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetHangingPreTimeLine", _m_SetHangingPreTimeLine_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TriggerGuideGroup", _m_TriggerGuideGroup_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TriggerGuideAction", _m_TriggerGuideAction_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddGuideTag", _m_AddGuideTag_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GuideReady2Finish", _m_GuideReady2Finish_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginRpgEventBattle", _m_BeginRpgEventBattle_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginSurvivorBattle", _m_BeginSurvivorBattle_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowBattleStart", _m_ShowBattleStart_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckCanDeckGuideClick", _m_CheckCanDeckGuideClick_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginDeckGuideClick", _m_BeginDeckGuideClick_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "DeckGuideClickSuccess", _m_DeckGuideClickSuccess_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckCanDeckGuideDrag", _m_CheckCanDeckGuideDrag_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "BeginDeckGuideDrag", _m_BeginDeckGuideDrag_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "DeckGuideDragSuccess", _m_DeckGuideDragSuccess_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasPassRpgLevel", _m_HasPassRpgLevel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasPassGuideEvent", _m_HasPassGuideEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasFinishCityEvent", _m_HasFinishCityEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasBuilding", _m_HasBuilding_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasResource", _m_HasResource_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasCityEvent", _m_HasCityEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasPrettyGirls", _m_HasPrettyGirls_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasEmployee", _m_HasEmployee_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsCityBusinessStateMatch", _m_IsCityBusinessStateMatch_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsIndustryCanBuild", _m_IsIndustryCanBuild_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsCityTaskGroupNow", _m_IsCityTaskGroupNow_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddCityTaskCount", _m_AddCityTaskCount_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCityTask", _m_GetCityTask_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchSceneCamera", _m_SwitchSceneCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchThirdPersonController", _m_SwitchThirdPersonController_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayVideo", _m_PlayVideo_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayCommanderShow", _m_PlayCommanderShow_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowStreetOccupyEffect", _m_ShowStreetOccupyEffect_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TriggerGoto", _m_TriggerGoto_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "InterruptGoto", _m_InterruptGoto_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClientReport", _m_ClientReport_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayEnterCityCamera", _m_PlayEnterCityCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayDeblockAnim", _m_PlayDeblockAnim_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondConfirmDeblock", _m_SecondConfirmDeblock_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayPowerUpAnim", _m_PlayPowerUpAnim_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayChapterAnim", _m_PlayChapterAnim_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowWebImage", _m_ShowWebImage_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowGetNewHero", _m_ShowGetNewHero_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchSandboxLod", _m_SwitchSandboxLod_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveSandboxPos", _m_MoveSandboxPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateLoadingProgress", _m_UpdateLoadingProgress_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityNpcDisplay", _m_SwitchCityNpcDisplay_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchHudDisplay", _m_SwitchHudDisplay_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchAllHudDisplay", _m_SwitchAllHudDisplay_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ResetScene", _m_ResetScene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Switch2Scene", _m_Switch2Scene_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "DispatchNews", _m_DispatchNews_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "DispatchLuaEvent", _m_DispatchLuaEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowMainUi", _m_ShowMainUi_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchEventEntity", _m_SwitchEventEntity_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPlayerChessPieceVisible", _m_SetPlayerChessPieceVisible_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCityRoofVisible", _m_SetCityRoofVisible_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "RequestBuildingLvUp", _m_RequestBuildingLvUp_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "RequestCompleteAreaEvent", _m_RequestCompleteAreaEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CacheCityCameraPos", _m_CacheCityCameraPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "RecoverCacheCityCameraPos", _m_RecoverCacheCityCameraPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "FocusCityEvent", _m_FocusCityEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "FocusCityBuilding", _m_FocusCityBuilding_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "FocusCityPos", _m_FocusCityPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeCityEvent", _m_ChangeCityEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityFog", _m_SwitchCityFog_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityCamera", _m_SwitchCityCamera_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityTouchInput", _m_SwitchCityTouchInput_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddEventCache", _m_AddEventCache_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearEventCache", _m_ClearEventCache_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetForewordTask", _m_SetForewordTask_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "StreetEventCountDown", _m_StreetEventCountDown_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "StreetEventCountDownPause", _m_StreetEventCountDownPause_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "StreetEventCountDownResume", _m_StreetEventCountDownResume_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ExeEventFunc", _m_ExeEventFunc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateStreetEventTips", _m_UpdateStreetEventTips_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadBpStreetEventComplete", _m_LoadBpStreetEventComplete_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenStreetInteractivePanel", _m_OpenStreetInteractivePanel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CloseStreetInteractivePanel", _m_CloseStreetInteractivePanel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchExitVehicleOperation", _m_SwitchExitVehicleOperation_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearLuaFunction", _m_ClearLuaFunction_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearAllLuaFunctions", _m_ClearAllLuaFunctions_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TimeLineJumpToTime", _m_TimeLineJumpToTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SendGraphEvent", _m_SendGraphEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteTimelineResultEvent", _m_WriteTimelineResultEvent_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateCityObject", _m_CreateCityObject_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveCityObject", _m_RemoveCityObject_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ShowCityEventHud", _m_ShowCityEventHud_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SwitchCityBuildingLvUpShowingState", _m_SwitchCityBuildingLvUpShowingState_xlua_st_);
            
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLAYER_NPC_ID", Yoozoo.Gameplay.Liberty.BlueprintUtils.PLAYER_NPC_ID);
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "RecordList", _g_get_RecordList);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BlueprintPoints", _g_get_BlueprintPoints);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "RandomBlueprintPoints", _g_get_RandomBlueprintPoints);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BlueprintCounters", _g_get_BlueprintCounters);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "TimelineManager", _g_get_TimelineManager);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LibertyManager", _g_get_LibertyManager);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerController", _g_get_PlayerController);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PlayerEntity", _g_get_PlayerEntity);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "RecordList", _s_set_RecordList);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BlueprintPoints", _s_set_BlueprintPoints);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "RandomBlueprintPoints", _s_set_RandomBlueprintPoints);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BlueprintCounters", _s_set_BlueprintCounters);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "TimelineManager", _s_set_TimelineManager);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LibertyManager", _s_set_LibertyManager);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerController", _s_set_PlayerController);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PlayerEntity", _s_set_PlayerEntity);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            return LuaAPI.luaL_error(L, "Yoozoo.Gameplay.Liberty.BlueprintUtils does not have a constructor!");
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            return LuaAPI.luaL_error(L, "Yoozoo.Gameplay.Liberty.BlueprintUtils does not have a constructor!");
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPlayerCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetPlayerCamera(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Yoozoo.Gameplay.Liberty.GameCameraEnum _cameraEnum;translator.Get(L, 1, out _cameraEnum);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetCamera( _cameraEnum );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsPlayerTriggerCollider_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Collider _col = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider));
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsPlayerTriggerCollider( _col );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasBeenRecorded_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _record = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasBeenRecorded( _record );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearAllRecord_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearAllRecord(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetBlueprintPoint_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _pointName = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetBlueprintPoint( _pointName );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRandomBlueprintPoint_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetRandomBlueprintPoint(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ChangeCameraBlend_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Cinemachine.CinemachineBlendDefinition.Style _style;translator.Get(L, 1, out _style);
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ChangeCameraBlend( _style, _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchMovementInput_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _allow = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchMovementInput( _allow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchRootMotion_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _allow = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchRootMotion( _allow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCameraInput_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _allow = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCameraInput( _allow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnlySwitchCameraInput_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _allow = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OnlySwitchCameraInput( _allow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchPlayerInputController_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _allow = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchPlayerInputController( _allow );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryGetBlueprintCounter_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.TryGetBlueprintCounter( _name );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPlayerFreeAimOpen_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerFreeAimOpen( _isOpen );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPlayerKeepBattleDuration_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _duration = (float)LuaAPI.lua_tonumber(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerKeepBattleDuration( _duration );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayerTransmission_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Vector3 _pos;translator.Get(L, 1, out _pos);
                    UnityEngine.Vector3 _rot;translator.Get(L, 2, out _rot);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayerTransmission( _pos, _rot );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPlayerDestination_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<Yoozoo.Gameplay.Liberty.PlayerController.NavType>(L, 2)) 
                {
                    UnityEngine.Vector3 _destination;translator.Get(L, 1, out _destination);
                    Yoozoo.Gameplay.Liberty.PlayerController.NavType _navType;translator.Get(L, 2, out _navType);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerDestination( _destination, _navType );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& translator.Assignable<UnityEngine.Vector3>(L, 1)) 
                {
                    UnityEngine.Vector3 _destination;translator.Get(L, 1, out _destination);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerDestination( _destination );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerDestination!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsMainPlayer_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Collider _collider = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider));
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsMainPlayer( _collider );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayTimeline_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 10&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& translator.Assignable<UnityEngine.Transform>(L, 9)&& translator.Assignable<Yoozoo.Gameplay.Liberty.ETimelinePathType>(L, 10)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    string _path = LuaAPI.lua_tostring(L, 6);
                    string _cameraType = LuaAPI.lua_tostring(L, 7);
                    float _planeDistance = (float)LuaAPI.lua_tonumber(L, 8);
                    UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 9, typeof(UnityEngine.Transform));
                    Yoozoo.Gameplay.Liberty.ETimelinePathType _pathType;translator.Get(L, 10, out _pathType);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode, _path, _cameraType, _planeDistance, _parent, _pathType );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 9&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& translator.Assignable<UnityEngine.Transform>(L, 9)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    string _path = LuaAPI.lua_tostring(L, 6);
                    string _cameraType = LuaAPI.lua_tostring(L, 7);
                    float _planeDistance = (float)LuaAPI.lua_tonumber(L, 8);
                    UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 9, typeof(UnityEngine.Transform));
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode, _path, _cameraType, _planeDistance, _parent );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 8&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    string _path = LuaAPI.lua_tostring(L, 6);
                    string _cameraType = LuaAPI.lua_tostring(L, 7);
                    float _planeDistance = (float)LuaAPI.lua_tonumber(L, 8);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode, _path, _cameraType, _planeDistance );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 7&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    string _path = LuaAPI.lua_tostring(L, 6);
                    string _cameraType = LuaAPI.lua_tostring(L, 7);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode, _path, _cameraType );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    string _path = LuaAPI.lua_tostring(L, 6);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode, _path );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)&& translator.Assignable<UnityEngine.Playables.DirectorWrapMode>(L, 5)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    UnityEngine.Playables.DirectorWrapMode _wrapMode;translator.Get(L, 5, out _wrapMode);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart, _wrapMode );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2)&& translator.Assignable<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3)&& translator.Assignable<System.Action>(L, 4)) 
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStart = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action _onPreStart = translator.GetDelegate<System.Action>(L, 4);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline( _name, _onStopped, _onStart, _onPreStart );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayTimeline!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StopTimeline_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.StopTimeline( _name );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Pause_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Pause(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Resume_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Resume(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayEffect_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _configId = LuaAPI.xlua_tointeger(L, 1);
                    int _uniqueId = LuaAPI.xlua_tointeger(L, 2);
                    UnityEngine.Vector3 _pos;translator.Get(L, 3, out _pos);
                    UnityEngine.Vector3 _angle;translator.Get(L, 4, out _angle);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayEffect( _configId, _uniqueId, _pos, _angle );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DestroyEffect_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _uniqueId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.DestroyEffect( _uniqueId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddNpc_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _npcName = LuaAPI.lua_tostring(L, 1);
                    int _uniqueId = LuaAPI.xlua_tointeger(L, 2);
                    UnityEngine.Vector3 _pos;translator.Get(L, 3, out _pos);
                    UnityEngine.Quaternion _rot;translator.Get(L, 4, out _rot);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddNpc( _npcName, _uniqueId, _pos, _rot );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveNpc_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _uniqueId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.RemoveNpc( _uniqueId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetNpc_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _uniqueId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetNpc( _uniqueId );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPlayerNpcRigidBody_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetPlayerNpcRigidBody(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OperateLookAtCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    UnityEngine.Vector3 _eulerAngles;translator.Get(L, 2, out _eulerAngles);
                    float _fov = (float)LuaAPI.lua_tonumber(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OperateLookAtCamera( _position, _eulerAngles, _fov );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OperatePlayerInputCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _localAngleH = (float)LuaAPI.lua_tonumber(L, 1);
                    float _localAngleV = (float)LuaAPI.lua_tonumber(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OperatePlayerInputCamera( _localAngleH, _localAngleV );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2LookAtCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 5&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Vector3>(L, 3)&& translator.Assignable<UnityEngine.Transform>(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    UnityEngine.Vector3 _eulerAngles;translator.Get(L, 2, out _eulerAngles);
                    UnityEngine.Vector3 _lookAtPos;translator.Get(L, 3, out _lookAtPos);
                    UnityEngine.Transform _lookAt = (UnityEngine.Transform)translator.GetObject(L, 4, typeof(UnityEngine.Transform));
                    float _fov = (float)LuaAPI.lua_tonumber(L, 5);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2LookAtCamera( _position, _eulerAngles, _lookAtPos, _lookAt, _fov );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 4&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Vector3>(L, 3)&& translator.Assignable<UnityEngine.Transform>(L, 4)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    UnityEngine.Vector3 _eulerAngles;translator.Get(L, 2, out _eulerAngles);
                    UnityEngine.Vector3 _lookAtPos;translator.Get(L, 3, out _lookAtPos);
                    UnityEngine.Transform _lookAt = (UnityEngine.Transform)translator.GetObject(L, 4, typeof(UnityEngine.Transform));
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2LookAtCamera( _position, _eulerAngles, _lookAtPos, _lookAt );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& translator.Assignable<UnityEngine.Vector3>(L, 1)&& translator.Assignable<UnityEngine.Vector3>(L, 2)&& translator.Assignable<UnityEngine.Vector3>(L, 3)) 
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 1, out _position);
                    UnityEngine.Vector3 _eulerAngles;translator.Get(L, 2, out _eulerAngles);
                    UnityEngine.Vector3 _lookAtPos;translator.Get(L, 3, out _lookAtPos);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2LookAtCamera( _position, _eulerAngles, _lookAtPos );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2LookAtCamera!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetInputCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ResetInputCamera(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2InputCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2InputCamera(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2HangingCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2HangingCamera(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2BehaviorCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<Yoozoo.Gameplay.Liberty.BehaviorCamera>>(L, 2)) 
                {
                    string _cameraName = LuaAPI.lua_tostring(L, 1);
                    System.Action<Yoozoo.Gameplay.Liberty.BehaviorCamera> _callBack = translator.GetDelegate<System.Action<Yoozoo.Gameplay.Liberty.BehaviorCamera>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2BehaviorCamera( _cameraName, _callBack );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
                {
                    string _cameraName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2BehaviorCamera( _cameraName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2BehaviorCamera!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLightController_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _mark = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetLightController( _mark );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsInGuide_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isInGuide = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetIsInGuide( _isInGuide );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInMainUI_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsInMainUI(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasRadarItem_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasRadarItem( _eventId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AutoReqClaimBuildingReward_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    int _buildingIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _targetLv = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.AutoReqClaimBuildingReward( _buildingId, _buildingIndex, _targetLv );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CallLuaFuncSwitch_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _funcName = LuaAPI.lua_tostring(L, 1);
                    string _argString = LuaAPI.lua_tostring(L, 2);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.CallLuaFuncSwitch( _funcName, _argString );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTroopHeroCount_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _troopIndex = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.GetTroopHeroCount( _troopIndex );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsUiShowing_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _pageName = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsUiShowing( _pageName );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsGuideConditionMatch_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _condition = LuaAPI.lua_tostring(L, 1);
                    int _state = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsGuideConditionMatch( _condition, _state );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsInScene( _sceneName );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SendRecordRequest_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _record = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SendRecordRequest( _record );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SendGuideRequest_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _groupId = LuaAPI.xlua_tointeger(L, 1);
                    int _guideId = LuaAPI.xlua_tointeger(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SendGuideRequest( _groupId, _guideId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OpenCloseUI_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 6&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action>(L, 6)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    string _panelName = LuaAPI.lua_tostring(L, 2);
                    string _param1 = LuaAPI.lua_tostring(L, 3);
                    string _param2 = LuaAPI.lua_tostring(L, 4);
                    string _param3 = LuaAPI.lua_tostring(L, 5);
                    System.Action _action = translator.GetDelegate<System.Action>(L, 6);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen, _panelName, _param1, _param2, _param3, _action );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 5&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    string _panelName = LuaAPI.lua_tostring(L, 2);
                    string _param1 = LuaAPI.lua_tostring(L, 3);
                    string _param2 = LuaAPI.lua_tostring(L, 4);
                    string _param3 = LuaAPI.lua_tostring(L, 5);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen, _panelName, _param1, _param2, _param3 );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 4&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    string _panelName = LuaAPI.lua_tostring(L, 2);
                    string _param1 = LuaAPI.lua_tostring(L, 3);
                    string _param2 = LuaAPI.lua_tostring(L, 4);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen, _panelName, _param1, _param2 );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    string _panelName = LuaAPI.lua_tostring(L, 2);
                    string _param1 = LuaAPI.lua_tostring(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen, _panelName, _param1 );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    string _panelName = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen, _panelName );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) 
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI( _isOpen );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenCloseUI!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UIIsShowing_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _pageName = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.UIIsShowing( _pageName );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowDialoguePanel_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    int _childId = LuaAPI.xlua_tointeger(L, 2);
                    FlowCanvas.FlowNode _parentNode = (FlowCanvas.FlowNode)translator.GetObject(L, 3, typeof(FlowCanvas.FlowNode));
                    bool _autoClose = LuaAPI.lua_toboolean(L, 4);
                    float _autoCloseTime = (float)LuaAPI.lua_tonumber(L, 5);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowDialoguePanel( _id, _childId, _parentNode, _autoClose, _autoCloseTime );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowMovieBlackEffect_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    bool _isOpen = LuaAPI.lua_toboolean(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowMovieBlackEffect( _isOpen, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UnlockAirWall_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _wallName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.UnlockAirWall( _wallName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LockAirWall_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _wallName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.LockAirWall( _wallName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddFeatureAirWall_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _wallName = LuaAPI.lua_tostring(L, 1);
                    UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos);
                    UnityEngine.Quaternion _rot;translator.Get(L, 3, out _rot);
                    UnityEngine.Vector3 _scale;translator.Get(L, 4, out _scale);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddFeatureAirWall( _wallName, _pos, _rot, _scale );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Yoozoo.Gameplay.Liberty.Nodes.EnterCityScene.CitySceneType _sceneType;translator.Get(L, 1, out _sceneType);
                    System.Action _callback = translator.GetDelegate<System.Action>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityScene( _sceneType, _callback );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2HangingScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action _callBack = translator.GetDelegate<System.Action>(L, 1);
                    string _mark = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2HangingScene( _callBack, _mark );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetHangingPreTimeLine_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _bluePrintName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetHangingPreTimeLine( _bluePrintName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TriggerGuideGroup_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _groupId = LuaAPI.xlua_tointeger(L, 1);
                    int _guideId = LuaAPI.xlua_tointeger(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.TriggerGuideGroup( _groupId, _guideId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TriggerGuideAction_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _actionType = LuaAPI.xlua_tointeger(L, 1);
                    string _actionParams = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.TriggerGuideAction( _actionType, _actionParams );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddGuideTag_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _tagName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddGuideTag( _tagName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GuideReady2Finish_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.GuideReady2Finish(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BeginRpgEventBattle_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _levelId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.BeginRpgEventBattle( _levelId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BeginSurvivorBattle_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _missionId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.BeginSurvivorBattle( _missionId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowBattleStart_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowBattleStart(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckCanDeckGuideClick_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.CheckCanDeckGuideClick( _heroId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BeginDeckGuideClick_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.BeginDeckGuideClick( _heroId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DeckGuideClickSuccess_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.DeckGuideClickSuccess( _heroId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckCanDeckGuideDrag_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.CheckCanDeckGuideDrag( _heroId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_BeginDeckGuideDrag_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.BeginDeckGuideDrag( _heroId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DeckGuideDragSuccess_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.DeckGuideDragSuccess( _heroId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasPassRpgLevel_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _levelId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasPassRpgLevel( _levelId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasPassGuideEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _guideEventId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasPassGuideEvent( _guideEventId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasFinishCityEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasFinishCityEvent( _eventId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasBuilding_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    int _num = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasBuilding( _buildingId, _level, _num );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasResource_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _type = LuaAPI.xlua_tointeger(L, 1);
                    int _id = LuaAPI.xlua_tointeger(L, 2);
                    int _num = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasResource( _type, _id, _num );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasCityEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasCityEvent( _eventId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasPrettyGirls_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasPrettyGirls(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasEmployee_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    int _employeeId = LuaAPI.xlua_tointeger(L, 2);
                    int _level = LuaAPI.xlua_tointeger(L, 3);
                    int _num = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.HasEmployee( _buildingId, _employeeId, _level, _num );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCityBusinessStateMatch_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _state = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsCityBusinessStateMatch( _state );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsIndustryCanBuild_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _indID = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsIndustryCanBuild( _indID );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCityTaskGroupNow_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _groupID = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = Yoozoo.Gameplay.Liberty.BlueprintUtils.IsCityTaskGroupNow( _groupID );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddCityTaskCount_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _taskId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddCityTaskCount( _taskId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCityTask_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _taskId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.GetCityTask( _taskId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchSceneCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _state = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchSceneCamera( _state );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchThirdPersonController_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _enable = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchThirdPersonController( _enable );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayVideo_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayVideo( _name, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayCommanderShow_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _heroId = LuaAPI.lua_tostring(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onFirstFrame = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onFinish = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayCommanderShow( _heroId, _onFirstFrame, _onFinish );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowStreetOccupyEffect_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _streetId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowStreetOccupyEffect( _streetId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TriggerGoto_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _gotoId = LuaAPI.xlua_tointeger(L, 1);
                    bool _keepInGuide = LuaAPI.lua_toboolean(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onException = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 4);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.TriggerGoto( _gotoId, _keepInGuide, _onStopped, _onException );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InterruptGoto_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _gotoId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.InterruptGoto( _gotoId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClientReport_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClientReport( _eventId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayEnterCityCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayEnterCityCamera( _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayDeblockAnim_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _deblockId = LuaAPI.xlua_tointeger(L, 1);
                    string _title = LuaAPI.lua_tostring(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayDeblockAnim( _deblockId, _title, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondConfirmDeblock_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _deblockId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SecondConfirmDeblock( _deblockId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayPowerUpAnim_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _fromValue = LuaAPI.xlua_tointeger(L, 1);
                    int _toValue = LuaAPI.xlua_tointeger(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onComplete = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayPowerUpAnim( _fromValue, _toValue, _onComplete );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PlayChapterAnim_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chapterId = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayChapterAnim( _chapterId, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowWebImage_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _webId = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowWebImage( _webId, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowGetNewHero_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.List<int> _heroes = (System.Collections.Generic.List<int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<int>));
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowGetNewHero( _heroes, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchSandboxLod_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _lod = LuaAPI.xlua_tointeger(L, 1);
                    int _percent = LuaAPI.xlua_tointeger(L, 2);
                    float _time = (float)LuaAPI.lua_tonumber(L, 3);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 4);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchSandboxLod( _lod, _percent, _time, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_MoveSandboxPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _key = LuaAPI.lua_tostring(L, 1);
                    float _time = (float)LuaAPI.lua_tonumber(L, 2);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.MoveSandboxPos( _key, _time, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateLoadingProgress_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _progress = LuaAPI.xlua_tointeger(L, 1);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.UpdateLoadingProgress( _progress, _msg );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityNpcDisplay_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _enable = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityNpcDisplay( _enable );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchHudDisplay_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    Yoozoo.Gameplay.City.CityHudEnum _hudEnum;translator.Get(L, 1, out _hudEnum);
                    bool _active = LuaAPI.lua_toboolean(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchHudDisplay( _hudEnum, _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchAllHudDisplay_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _active = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchAllHudDisplay( _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ResetScene_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    System.Action _callback = translator.GetDelegate<System.Action>(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ResetScene( _sceneName, _callback );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Switch2Scene_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    string _sceneParams = LuaAPI.lua_tostring(L, 2);
                    System.Action _callback = translator.GetDelegate<System.Action>(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.Switch2Scene( _sceneName, _sceneParams, _callback );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DispatchNews_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _newsId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.DispatchNews( _newsId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_DispatchLuaEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    int _argInt = LuaAPI.xlua_tointeger(L, 2);
                    string _argString = LuaAPI.lua_tostring(L, 3);
                    bool _argBool = LuaAPI.lua_toboolean(L, 4);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.DispatchLuaEvent( _eventId, _argInt, _argString, _argBool );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowMainUi_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowMainUi( _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchEventEntity_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    bool _active = LuaAPI.lua_toboolean(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchEventEntity( _eventId, _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPlayerChessPieceVisible_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isVisible = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetPlayerChessPieceVisible( _isVisible );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetCityRoofVisible_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _isVisible = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetCityRoofVisible( _isVisible );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RequestBuildingLvUp_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    int _buildingIndex = LuaAPI.xlua_tointeger(L, 2);
                    string _type = LuaAPI.lua_tostring(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.RequestBuildingLvUp( _buildingId, _buildingIndex, _type );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RequestCompleteAreaEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.RequestCompleteAreaEvent( _eventId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CacheCityCameraPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.CacheCityCameraPos(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RecoverCacheCityCameraPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.RecoverCacheCityCameraPos(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FocusCityEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);
                    float _time = (float)LuaAPI.lua_tonumber(L, 5);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 6);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.FocusCityEvent( _eventId, _x, _y, _z, _time, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FocusCityBuilding_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    float _x = (float)LuaAPI.lua_tonumber(L, 2);
                    float _y = (float)LuaAPI.lua_tonumber(L, 3);
                    float _z = (float)LuaAPI.lua_tonumber(L, 4);
                    float _time = (float)LuaAPI.lua_tonumber(L, 5);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 6);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.FocusCityBuilding( _buildingId, _x, _y, _z, _time, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_FocusCityPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 1);
                    float _y = (float)LuaAPI.lua_tonumber(L, 2);
                    float _z = (float)LuaAPI.lua_tonumber(L, 3);
                    float _time = (float)LuaAPI.lua_tonumber(L, 4);
                    System.Action<UnityEngine.Playables.PlayableDirector> _onStopped = translator.GetDelegate<System.Action<UnityEngine.Playables.PlayableDirector>>(L, 5);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.FocusCityPos( _x, _y, _z, _time, _onStopped );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ChangeCityEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    bool _showHud = LuaAPI.lua_toboolean(L, 2);
                    bool _showEffect = LuaAPI.lua_toboolean(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ChangeCityEvent( _eventId, _showHud, _showEffect );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityFog_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _active = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityFog( _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityCamera_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _active = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityCamera( _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityTouchInput_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    bool _active = LuaAPI.lua_toboolean(L, 1);
                    bool _keepInGuide = LuaAPI.lua_toboolean(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityTouchInput( _active, _keepInGuide );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) 
                {
                    bool _active = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityTouchInput( _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityTouchInput!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddEventCache_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    string _eventName = LuaAPI.lua_tostring(L, 2);
                    bool _isVTask = LuaAPI.lua_toboolean(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddEventCache( _sceneName, _eventName, _isVTask );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    string _eventName = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.AddEventCache( _sceneName, _eventName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.AddEventCache!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearEventCache_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    string _eventName = LuaAPI.lua_tostring(L, 2);
                    bool _isVTask = LuaAPI.lua_toboolean(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearEventCache( _sceneName, _eventName, _isVTask );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    string _sceneName = LuaAPI.lua_tostring(L, 1);
                    string _eventName = LuaAPI.lua_tostring(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearEventCache( _sceneName, _eventName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearEventCache!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetForewordTask_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _state = LuaAPI.lua_toboolean(L, 1);
                    int _taskId = LuaAPI.xlua_tointeger(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SetForewordTask( _state, _taskId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StreetEventCountDown_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _time = (float)LuaAPI.lua_tonumber(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.StreetEventCountDown( _time );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StreetEventCountDownPause_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.StreetEventCountDownPause(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StreetEventCountDownResume_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.StreetEventCountDownResume(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ExeEventFunc_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _funcName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ExeEventFunc( _funcName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateStreetEventTips_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _langKey = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.UpdateStreetEventTips( _langKey );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadBpStreetEventComplete_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _streetEventId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.LoadBpStreetEventComplete( _streetEventId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OpenStreetInteractivePanel_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _actionId = LuaAPI.xlua_tointeger(L, 1);
                    string _langKey = LuaAPI.lua_tostring(L, 2);
                    string _iconPath = LuaAPI.lua_tostring(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.OpenStreetInteractivePanel( _actionId, _langKey, _iconPath );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CloseStreetInteractivePanel_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.CloseStreetInteractivePanel(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchExitVehicleOperation_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _enable = LuaAPI.lua_toboolean(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchExitVehicleOperation( _enable );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearLuaFunction_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearLuaFunction(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearAllLuaFunctions_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ClearAllLuaFunctions(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TimeLineJumpToTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _tname = LuaAPI.lua_tostring(L, 1);
                    double _toTime = LuaAPI.lua_tonumber(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.TimeLineJumpToTime( _tname, _toTime );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SendGraphEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _eventName = LuaAPI.lua_tostring(L, 1);
                    FlowCanvas.FlowNode _sender = (FlowCanvas.FlowNode)translator.GetObject(L, 2, typeof(FlowCanvas.FlowNode));
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SendGraphEvent( _eventName, _sender );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_WriteTimelineResultEvent_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _eventName = LuaAPI.lua_tostring(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.WriteTimelineResultEvent( _eventName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CreateCityObject_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    string _aniName = LuaAPI.lua_tostring(L, 2);
                    UnityEngine.Vector3 _position;translator.Get(L, 3, out _position);
                    UnityEngine.Vector3 _rotation;translator.Get(L, 4, out _rotation);
                    int _id = LuaAPI.xlua_tointeger(L, 5);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.CreateCityObject( _name, _aniName, _position, _rotation, _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveCityObject_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    int _id = LuaAPI.xlua_tointeger(L, 2);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.RemoveCityObject( _name, _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowCityEventHud_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _eventId = LuaAPI.xlua_tointeger(L, 1);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.ShowCityEventHud( _eventId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SwitchCityBuildingLvUpShowingState_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _buildingId = LuaAPI.xlua_tointeger(L, 1);
                    int _buildingIndex = LuaAPI.xlua_tointeger(L, 2);
                    bool _active = LuaAPI.lua_toboolean(L, 3);
                    
                    Yoozoo.Gameplay.Liberty.BlueprintUtils.SwitchCityBuildingLvUpShowingState( _buildingId, _buildingIndex, _active );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RecordList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.RecordList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_BlueprintPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.BlueprintPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RandomBlueprintPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.RandomBlueprintPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_BlueprintCounters(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.BlueprintCounters);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TimelineManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.TimelineManager);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_LibertyManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.LibertyManager);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerController(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayerController);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PlayerEntity(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayerEntity);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_RecordList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.RecordList = (System.Collections.Generic.HashSet<string>)translator.GetObject(L, 1, typeof(System.Collections.Generic.HashSet<string>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_BlueprintPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.BlueprintPoints = (System.Collections.Generic.Dictionary<string, Yoozoo.Gameplay.Liberty.BluePrintPoint>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, Yoozoo.Gameplay.Liberty.BluePrintPoint>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_RandomBlueprintPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.RandomBlueprintPoints = (System.Collections.Generic.List<Yoozoo.Gameplay.Liberty.BluePrintPoint>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<Yoozoo.Gameplay.Liberty.BluePrintPoint>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_BlueprintCounters(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.BlueprintCounters = (System.Collections.Generic.Dictionary<string, Yoozoo.Gameplay.Liberty.BlueprintCounter>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, Yoozoo.Gameplay.Liberty.BlueprintCounter>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TimelineManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.TimelineManager = (Yoozoo.Gameplay.Liberty.TimelineManager)translator.GetObject(L, 1, typeof(Yoozoo.Gameplay.Liberty.TimelineManager));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_LibertyManager(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.LibertyManager = (Yoozoo.Gameplay.Liberty.LibertyManager)translator.GetObject(L, 1, typeof(Yoozoo.Gameplay.Liberty.LibertyManager));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerController(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayerController = (Yoozoo.Gameplay.Liberty.PlayerController.PlayerControlModeMgr)translator.GetObject(L, 1, typeof(Yoozoo.Gameplay.Liberty.PlayerController.PlayerControlModeMgr));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_PlayerEntity(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    Yoozoo.Gameplay.Liberty.BlueprintUtils.PlayerEntity = (Yoozoo.Gameplay.Liberty.PlayerController.PlayerEntity)translator.GetObject(L, 1, typeof(Yoozoo.Gameplay.Liberty.PlayerController.PlayerEntity));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
